StartCompress(Int32,Int32,Int32,RasterByteOrder,RasterViewPerspective,Int32,Byte[],Int32,Int32,CodecsCompression,CodecsCompressDataCallback) Method

using Leadtools;
using Leadtools.Codecs;
using Leadtools.ImageProcessing;
using Leadtools.ImageProcessing.Color;

      
public async Task CompressExample()
{
   Debug.WriteLine("RasterCodecs.Compress - 0");
   RasterCodecs codecs = new RasterCodecs();
   Debug.WriteLine("RasterCodecs.Compress - 1");

   string srcFileName = @"Assets\Image1.cmp";
   string destFileName = "Image1_CompressData.cmp";

   // Load the image to at 24-bits per pixel
   IStorageFile loadFile = await Tools.AppInstallFolder.GetFileAsync(srcFileName);
   RasterImage image = await codecs.LoadAsync(LeadStreamFactory.Create(loadFile), 24, CodecsLoadByteOrder.Bgr, 1, 1);
   if (image.ViewPerspective != RasterViewPerspective.TopLeft)
      image.ChangeViewPerspective(RasterViewPerspective.TopLeft);

   // Create the output file
   IStorageFile saveFile = await Tools.AppLocalFolder.CreateFileAsync(destFileName);
   _compressStream = await saveFile.OpenStreamForWriteAsync();

   // Calculate the bytes per line in the input buffer, without padding 
   int lineBytes = image.Width * 3;

   // Allocate a buffer for the incoming uncompressed data. Note that we
   //  are compressing 16 lines at a time. You should always use multiples of 16
   byte[] inBuffer = new byte[16 * lineBytes];

   // Lock down the image
   image.AccessData();

   // Let the function allocate a buffer of 1024 bytes for storing the compressed data
   // This buffer will be passed to our callback

   // Initialize the compression engine
   codecs.Options.Jpeg.Save.CmpQualityFactorPredefined = CodecsCmpQualityFactorPredefined.QualityAndSize;
   codecs.StartCompress(
      image.Width,
      image.Height,
      image.BitsPerPixel,
      image.Order,
      image.ViewPerspective,
      16 * lineBytes,
      1024,
      CodecsCompression.Cmp,
      MyCodecsCompressDataCallback);

   // Compress the data
   int i = 0;
   while (i < image.Height) // i is incremented at the end
   {
      // Compression of the 16-line chunk starts here
      int j = 0;
      int inBufferIndex = 0;
      while ((i + j) < image.Height && j < 16)
      {
         byte[] lineBuffer = new byte[lineBytes];

         // Get one line at time. I cannot read into inBuffer directly because buffer passed to GetRow is write-only
         // and its contents is destroyed when you call GetRow. 
         image.GetRow(i + j, lineBuffer, 0, lineBytes);

         // copy the one-row lineBuffer to the 16-row lineBuffer
         Array.Copy(lineBuffer, 0, inBuffer, j * lineBytes, lineBytes);

         // Move to next line
         inBufferIndex += lineBytes;

         j++;
      }

      // This is the main function that will do the actual Compression
      codecs.Compress(inBuffer, 0);
      i += 16;
   }

   // Reset the compression engine 
   codecs.StopCompress();

   // Release the image and close the file
   image.ReleaseData();
   _compressStream.Dispose();

   // Clean up
   codecs.Dispose();
}

Stream _compressStream;
byte[] _compressBuffer;

bool MyCodecsCompressDataCallback(int width, int height, int bitsPerPixel, RasterByteOrder order, RasterViewPerspective viewPerspective, RasterNativeBuffer buffer)
{
   int bufferLength = (int)buffer.Length;
   // Write data to the file
   if (_compressBuffer == null || _compressBuffer.Length < bufferLength)
      _compressBuffer = new byte[bufferLength];

   buffer.GetData(0, _compressBuffer, 0, bufferLength);
   _compressStream.Write(_compressBuffer, 0, bufferLength);

   return true;
}